/**
 * 存储工具模块
 * @description 导出所有存储相关的工具函数和类
 */

// 导出本地存储工具
export { LocalStorageUtils } from './localStorage';
export {
  setLocalStorage,
  getLocalStorage,
  removeLocalStorage,
  hasLocalStorage,
  cleanupLocalStorage,
  getLocalStorageStats
} from './localStorage';

// 导出会话存储工具
export { SessionStorageUtils } from './sessionStorage';
export {
  setSessionStorage,
  getSessionStorage,
  removeSessionStorage,
  hasSessionStorage,
  getSessionStorageStats,
  getCurrentSessionId,
  getSessionDuration
} from './sessionStorage';

// 导出类型定义
export type {
  IStorageWrapper,
  IStorageResult,
  IStorageStats
} from './localStorage';

export type {
  ISessionStorageWrapper,
  ISessionStorageResult,
  ISessionStorageStats
} from './sessionStorage';

// 导出统一的存储管理器
import { LocalStorageUtils } from './localStorage';
import { SessionStorageUtils } from './sessionStorage';
import { STORAGE_KEYS, SESSION_STORAGE_KEYS } from '@/constants/storage';

/**
 * 统一存储管理器
 * @description 提供统一的存储接口，自动选择合适的存储方式
 */
export class StorageManager {
  /**
   * 存储数据（自动选择存储方式）
   * @param key 存储键
   * @param data 数据
   * @param options 选项
   * @returns 存储结果
   */
  static setItem<T>(
    key: string, 
    data: T, 
    options: {
      /** 存储类型：local（持久）或 session（会话） */
      storageType?: 'local' | 'session';
      /** 过期时间（仅本地存储有效） */
      expiresIn?: number;
      /** 数据类型 */
      type?: string;
    } = {}
  ) {
    const { storageType = 'local', ...restOptions } = options;
    
    if (storageType === 'session') {
      return SessionStorageUtils.setItem(key, data, restOptions);
    } else {
      return LocalStorageUtils.setItem(key, data, restOptions);
    }
  }

  /**
   * 获取数据（自动检测存储方式）
   * @param key 存储键
   * @param storageType 优先的存储类型
   * @returns 存储结果
   */
  static getItem<T>(key: string, storageType?: 'local' | 'session') {
    if (storageType === 'session') {
      return SessionStorageUtils.getItem<T>(key);
    } else if (storageType === 'local') {
      return LocalStorageUtils.getItem<T>(key);
    } else {
      // 自动检测：先检查本地存储，再检查会话存储
      const localResult = LocalStorageUtils.getItem<T>(key);
      if (localResult.success) {
        return localResult;
      }
      return SessionStorageUtils.getItem<T>(key);
    }
  }

  /**
   * 删除数据（从所有存储中删除）
   * @param key 存储键
   * @returns 操作结果
   */
  static removeItem(key: string) {
    const localResult = LocalStorageUtils.removeItem(key);
    const sessionResult = SessionStorageUtils.removeItem(key);
    
    return {
      success: localResult.success || sessionResult.success,
      timestamp: Date.now()
    };
  }

  /**
   * 检查键是否存在（检查所有存储）
   * @param key 存储键
   * @returns 是否存在
   */
  static hasItem(key: string): boolean {
    return LocalStorageUtils.hasItem(key) || SessionStorageUtils.hasItem(key);
  }

  /**
   * 清理所有过期数据
   * @returns 清理结果
   */
  static cleanup() {
    const localCleanup = LocalStorageUtils.cleanup();
    // 会话存储不需要清理过期数据（会话结束自动清理）
    
    return localCleanup;
  }

  /**
   * 获取存储统计信息
   * @returns 统计信息
   */
  static getStats() {
    const localStats = LocalStorageUtils.getStats();
    const sessionStats = SessionStorageUtils.getStats();
    
    return {
      local: localStats,
      session: sessionStats,
      total: {
        usedSpace: localStats.usedSpace + sessionStats.usedSpace,
        itemCount: localStats.itemCount + sessionStats.itemCount
      }
    };
  }
}

/**
 * 业务数据存储工具
 * @description 提供业务特定的存储操作
 */
export class BusinessStorageUtils {
  /**
   * 存储学生数据
   * @param students 学生数据数组
   * @returns 存储结果
   */
  static setStudents(students: unknown[]) {
    return LocalStorageUtils.setItem(STORAGE_KEYS.STUDENTS, students, {
      type: 'students',
      expiresIn: -1 // 永不过期
    });
  }

  /**
   * 获取学生数据
   * @returns 学生数据
   */
  static getStudents<T>() {
    return LocalStorageUtils.getItem<T[]>(STORAGE_KEYS.STUDENTS);
  }

  /**
   * 存储课程数据
   * @param courses 课程数据数组
   * @returns 存储结果
   */
  static setCourses(courses: unknown[]) {
    return LocalStorageUtils.setItem(STORAGE_KEYS.COURSES, courses, {
      type: 'courses',
      expiresIn: -1 // 永不过期
    });
  }

  /**
   * 获取课程数据
   * @returns 课程数据
   */
  static getCourses<T>() {
    return LocalStorageUtils.getItem<T[]>(STORAGE_KEYS.COURSES);
  }

  /**
   * 存储课程分类数据
   * @param categories 课程分类数据数组
   * @returns 存储结果
   */
  static setCourseCategories(categories: unknown[]) {
    return LocalStorageUtils.setItem(STORAGE_KEYS.COURSE_CATEGORIES, categories, {
      type: 'course_categories',
      expiresIn: -1 // 永不过期
    });
  }

  /**
   * 获取课程分类数据
   * @returns 课程分类数据
   */
  static getCourseCategories<T>() {
    return LocalStorageUtils.getItem<T[]>(STORAGE_KEYS.COURSE_CATEGORIES);
  }

  /**
   * 存储课程安排模板数据
   * @param templates 模板数据数组
   * @returns 存储结果
   */
  static setScheduleTemplates(templates: unknown[]) {
    return LocalStorageUtils.setItem(STORAGE_KEYS.SCHEDULE_TEMPLATES, templates, {
      type: 'schedule_templates',
      expiresIn: -1 // 永不过期
    });
  }

  /**
   * 获取课程安排模板数据
   * @returns 模板数据
   */
  static getScheduleTemplates<T>() {
    return LocalStorageUtils.getItem<T[]>(STORAGE_KEYS.SCHEDULE_TEMPLATES);
  }

  /**
   * 存储课程实例数据
   * @param instances 实例数据数组
   * @returns 存储结果
   */
  static setScheduleInstances(instances: unknown[]) {
    return LocalStorageUtils.setItem(STORAGE_KEYS.SCHEDULE_INSTANCES, instances, {
      type: 'schedule_instances',
      expiresIn: -1 // 永不过期
    });
  }

  /**
   * 获取课程实例数据
   * @returns 实例数据
   */
  static getScheduleInstances<T>() {
    return LocalStorageUtils.getItem<T[]>(STORAGE_KEYS.SCHEDULE_INSTANCES);
  }

  /**
   * 存储应用设置
   * @param settings 设置数据
   * @returns 存储结果
   */
  static setAppSettings(settings: unknown) {
    return LocalStorageUtils.setItem(STORAGE_KEYS.APP_SETTINGS, settings, {
      type: 'app_settings',
      expiresIn: -1 // 永不过期
    });
  }

  /**
   * 获取应用设置
   * @returns 设置数据
   */
  static getAppSettings<T>() {
    return LocalStorageUtils.getItem<T>(STORAGE_KEYS.APP_SETTINGS);
  }

  /**
   * 存储当前选中的学生（会话级别）
   * @param studentIds 学生ID数组
   * @returns 存储结果
   */
  static setSelectedStudents(studentIds: string[]) {
    return SessionStorageUtils.setItem(SESSION_STORAGE_KEYS.SELECTED_STUDENTS, studentIds, {
      type: 'selected_students'
    });
  }

  /**
   * 获取当前选中的学生
   * @returns 学生ID数组
   */
  static getSelectedStudents() {
    return SessionStorageUtils.getItem<string[]>(SESSION_STORAGE_KEYS.SELECTED_STUDENTS);
  }

  /**
   * 存储搜索历史（会话级别）
   * @param searchHistory 搜索历史数组
   * @returns 存储结果
   */
  static setSearchHistory(searchHistory: string[]) {
    return SessionStorageUtils.setItem(SESSION_STORAGE_KEYS.SEARCH_HISTORY, searchHistory, {
      type: 'search_history'
    });
  }

  /**
   * 获取搜索历史
   * @returns 搜索历史数组
   */
  static getSearchHistory() {
    return SessionStorageUtils.getItem<string[]>(SESSION_STORAGE_KEYS.SEARCH_HISTORY);
  }

  /**
   * 清空所有业务数据
   * @returns 清理结果
   */
  static clearAllBusinessData() {
    const keys = Object.keys(STORAGE_KEYS).map(key => STORAGE_KEYS[key as keyof typeof STORAGE_KEYS]);
    const sessionKeys = Object.keys(SESSION_STORAGE_KEYS).map(key => SESSION_STORAGE_KEYS[key as keyof typeof SESSION_STORAGE_KEYS]);
    
    let clearedCount = 0;
    
    // 清空本地存储的业务数据
    keys.forEach(key => {
      const result = LocalStorageUtils.removeItem(key);
      if (result.success) {
        clearedCount++;
      }
    });
    
    // 清空会话存储的业务数据
    sessionKeys.forEach(key => {
      const result = SessionStorageUtils.removeItem(key);
      if (result.success) {
        clearedCount++;
      }
    });
    
    return {
      success: true,
      data: { clearedCount },
      timestamp: Date.now()
    };
  }
}



/**
 * 导出便捷的业务存储函数
 */
export const setStudentsData = (students: unknown[]) => BusinessStorageUtils.setStudents(students);
export const getStudentsData = <T>() => BusinessStorageUtils.getStudents<T>();
export const setCoursesData = (courses: unknown[]) => BusinessStorageUtils.setCourses(courses);
export const getCoursesData = <T>() => BusinessStorageUtils.getCourses<T>();
export const setSelectedStudents = (studentIds: string[]) => BusinessStorageUtils.setSelectedStudents(studentIds);
export const getSelectedStudents = () => BusinessStorageUtils.getSelectedStudents();